/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2022-10-19
 * Time: 16:16
 */

import java.util.*;

/**
 * Set的使用  Set 中只存放了key值 -- 里面无法存放重复的元素
 */

class Student implements Comparable<Student> {
    public Student(int age) {
        this.age = age;
    }

    public int age;


    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }


    @Override
    public int compareTo(Student o) {
        if (this.age - o.age < 0) {
            return -1;
        } else if (this.age - o.age > 0) {
            return 1;
        } else {
            return 0;
        }

    }
}

public class Test_Set {

    private static void fun4(String str1 ,String str2) {
        HashSet<Character> set = new HashSet<>();
        // 将实际输出转为大写放入set中
        for ( char str: str2.toUpperCase().toCharArray()) {
            set.add(str);
        }
        HashSet<Character> badset = new HashSet<>();
        // 遍历str1与set中str2比较
        for (char str: str1.toUpperCase().toCharArray() ) {
            // badset中不包含则输出-- 去重坏键
            if(!set.contains(str) && !badset.contains(str)) {
                // 坏掉得没有输入得
                badset.add(str);
                System.out.print(str +" ");
            }
        }


    }
    public static void badkeyboard() {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNextLine()) {
            String str1 = scanner.nextLine(); // 需要输入得
            String str2 = scanner.nextLine(); // 实际输入得
            fun4(str1,str2);
        }
    }


    /**
     * 统计宝石出现得次数
     * @param jewels  所需统计得宝石标志
     * @param stones  石头中各种宝石
     * @return
     */
    public int numJewelsInStones(String jewels, String stones) {
        HashSet<Character> set = new HashSet<>();
        // 遍历宝石放入set中
        for(int i = 0; i < jewels.length(); i++) {
            char ch = jewels.charAt(i);
            set.add(ch);
        }
        // 统计
        int count = 0;
        for(int i = 0; i < stones.length(); i++) {
            char ch = stones.charAt(i);
            if(set.contains(ch)) {
                count++;
            }
        }
        return count;
    }

    /**
     * 返回数组中只出现一次得数字
     *
     * @param nums
     * @return
     */
    public static int singleNumber(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i])) {
                set.remove(nums[i]);
            } else {
                set.add(nums[i]);
            }
        }

        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i])) {
                return nums[i];
            }
        }

        return -1;
    }


    /**
     * 每个数据出现的次数
     *
     * @param array
     */
    public static void fun3(int[] array) {

    }

    /**
     * 数据当中第一个重复的数据
     *
     * @param array
     */
    public static void fun2(int[] array) {
        HashSet<Integer> hashSet = new HashSet<>();
        for (int i = 0; i < array.length; i++) {
            if (hashSet.contains(array[i])) {
                // set里面包含该数 则输出即为第一个出现重复的数
                System.out.println(array[i]);
                return;
            } else {
                // 不包含则放入set中
                hashSet.add(array[i]);
            }
        }
    }

    /**
     * //统计数据中不重复的数据
     *
     * @param array
     */
    public static void fun1(int[] array) {
        HashSet<Integer> hashSet = new HashSet<>();
        for (int i = 0; i < array.length; i++) {
            hashSet.add(array[i]);
        }
        System.out.println(hashSet);
    }

    public static void main(String[] args) {

        int[] array = new int[10_0000];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(1_0000); // 十万个数据均在0-9999之间
        }
        fun1(array);
    }

    public static void main2(String[] args) {
        // key值无法比较的类型不可以添加 -- 需要提供一个比较方法
        TreeSet<String> set = new TreeSet<>();
        set.add("zhangfei");
        set.add("lisi");  // 重复的数据不会被添加
        set.add("lisi");
        System.out.println(set);

        System.out.println(set.contains("zhangfei")); // 判断set中是否存在某个key

        System.out.println(set.size()); // 返回set的个数
        System.out.println(set.isEmpty()); // 判断set中是否为空

        Iterator<String> it = set.iterator(); // 返回set的迭代器
        // 迭代器的使用
        for (String x : set    // 类型:对象
        ) {
            System.out.println(x);
        }

        while (it.hasNext()) {
            // hasNext（） 判断集合是否还有元素
            String s = it.next(); // next（） 获取元素
            System.out.println(s);
        }

    }

        public boolean containsDuplicate(int[] nums) {
            HashSet<Integer> set = new HashSet<>();
            for(int i =0; i<nums.length; i++) {
                // 如果添加得元素存在-- add方法取反
                if(!set.add(nums[i])) {
                    return true;
                }
            }
            return false;
        }


    /**
     * 滑动窗口法
     * @param nums  整数数组
     * @param k nums[i] == nums[j]且 abs(i - j) <= k
     * @return true
     */
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Set<Integer> set = new HashSet<Integer>();
        int length = nums.length;
        for (int i = 0; i < length; i++) {
            //
            if (i > k) {
                set.remove(nums[i - k - 1]);
            }
            //在一个窗口中存在该元素了
            if (!set.add(nums[i])) {
                return true;
            }
        }
        return false;
    }



    public static void main1(String[] args) {
        TreeSet<String> set = new TreeSet<>();
        set.add("lisi");
        // key值相同时，不会被重复添加
        set.add("lisi");
        set.add("wangwu");
        System.out.println(set);

    }
}
